Purpose: Return a copy of an FSObjectRef such that the copy also needs to be disposed.
Inputs:
object_t The object ref to be cloned.
Outputs:
clone_o Copy of object_t.
Notes:
The value returned is the same value passed as input in object_t. This call
would typically be used to balance a future call to FSObjectRefDispose. Some
examples where it might be used:
* A called procedure needs to save an FSObjectRef for future use, but the
calling conventions dictate that the caller is responsible for disposing
of the ref. The called function could call FSObjectRefClone to make its
copy. The caller can safely dispose of the ref, yet the callee can use
the ref until doing its own dispose.
* In object-oriented programming, an object could be passed an FSObjectRef
in its constructor. The destructor would be expected to dispose the ref,
but so would the routine that created the object. FSObjectRefClone could
be used in the constructor.
The returned FSObjectRef is registered to the calling process (as must object_t).
}
FUNCTION FSObjectRefClone(object_t: FSObjectRef; VAR clone_o: FSObjectRef): OSStatus; C;
FUNCTION FSObjectRefCloneAsync(object_t: FSObjectRef; {CONST}VAR completion_i: KernelNotification; VAR clone_o: FSObjectRef; VAR requestID_o: MessageID): OSStatus; C;
{
Function: FSObjectRefDispose
Purpose: Dispose of an FSObjectRef previously returned to a process.
Inputs:
object_t The object ref to be disposed.
Outputs:
Notes:
A process must dispose of all FSObjectRefs returned to it. The FSObjectRefs
may be returned as explicit output parameters, or as properties. If a ref
is returned several times for a given object, it must be disposed for each
time it was returned.
When all refs to a given object are disposed, the File Manager will dispose
of any resources it allocated in order to operate on that object. All refs
for a process will be automatically disposed upon process termination.
For refs returned as properties (especially when iterating over muliple
objects), the FSObjectRefDisposeBulk call may be more convenient.
}
FUNCTION FSObjectRefDispose(object_t: FSObjectRef): OSStatus; C;
FUNCTION FSObjectRefDisposeAsync(object_t: FSObjectRef; {CONST}VAR completion_i: KernelNotification; VAR requestID_o: MessageID): OSStatus; C;
{
Function: FSObjectRefDisposeBulk
Purpose: Dispose of many FSObjectRefs, using a list of property descriptors.
(Typically used to dispose all refs returned by FSObjectIterate).
Inputs:
objectCount_i Number of objects returned by FSObjectIterate.
propertyCount_i Number of properties per object, as passed to FSObjectIterate.
statusBuffer_i Status buffer as returned by FSObjectIterate.
properties_i List of property descriptors passed to FSObjectIterate.
propertiesBuffer_i Buffer where property values were returned by FSObjectIterate.
Outputs:
statusBuffer_o Error status for each property of each object.
Notes:
This call is intended to make it easy to dispose of FSObjectRefs returned by an
FSObjectIterate call. You would pass the same property count, property descriptor
list and property value buffer as was passed to FSObjectIterate. You also pass the
object count and status buffer as returned by FSObjectIterate (since these tell which
properties were actually returned).
Any property in properties_i that does not contain an FSObjectRef is ignored. Any
property that does not have E_NoError in its propertyStatus field (in statusBuffer_i)
is ignored.
All elements of statusBuffer_o will be set. If the property was ignored (as described
above), then its propertyStatus is set to E_NoError; otherwise, it is set based on the
attempt to dispose of the ref. The propertyValueActualSize fields are all set to 0.
}
FUNCTION FSObjectRefDisposeBulk(objectCount_i: ItemCount; propertyCount_i: ItemCount; {CONST}VAR statusBuffer_i: FSBufferDescriptor; {CONST}VAR properties_i: FSPropertyDescriptor; {CONST}VAR propertiesBuffer_i: FSBufferDescriptor; VAR statusBuffer_o: FSBufferDescriptor): OSStatus; C;
{ }
FUNCTION FSObjectRefDisposeBulkAsync(objectCount_i: ItemCount; propertyCount_i: ItemCount; {CONST}VAR statusBuffer_i: FSBufferDescriptor; {CONST}VAR properties_i: FSPropertyDescriptor; {CONST}VAR propertiesBuffer_i: FSBufferDescriptor; {CONST}VAR completion_i: KernelNotification; VAR statusBuffer_o: FSBufferDescriptor; VAR requestID_o: MessageID): OSStatus; C;
{
Function: FSObjectRefRegister
Purpose: Allow an FSObjectRef to be used by another process.
Inputs:
senderObject_t The object ref.
receiverPid_i The other process that will be using senderObject_t.
Outputs:
Notes:
This call allows one process to send an FSObjectRef to another process
such that the other process can use the FSObjectRef itself. The process
specified by receiverPid_i must also dispose of senderObject_t. The File
Manager acts as if senderObject_t has been returned to receiverPid_i.
You might use this call if you have several processes where one process
(typically a server of some kind) obtains FSObjectRefs for use by other
processes (typically clients of that server). If the other process (as
specified by receiverPid_i) won't actually call the File Manager with
that FSObjectRef, then it doesn't need to be registered to that process.
It would also be possible to have the server process make all of the
calls to the File Manager. FSObjectRefs could still be passed between
client and server, but if the clients never use the refs directly, then
there would be no need to register the refs to those clients. (But beware:
the server would still be responsible for disposing of all refs returned to
it; the server would probably have some cleanup and disposal to do if one
of its client processes were to terminate.)
}
FUNCTION FSObjectRefRegister(senderObject_t: FSObjectRef; receiverPid_i: KernelProcessID): OSStatus; C;
FUNCTION FSObjectRefRegisterAsync(senderObject_t: FSObjectRef; receiverPid_i: KernelProcessID; {CONST}VAR completion_i: KernelNotification; VAR requestID_o: MessageID): OSStatus; C;
Purpose: Returns an FSObjectRef for a Volume Set specified by an
FSVolumeSetObjID.
Inputs:
volumeSet_t The volume set.
Outputs:
object_o Object ref for the volume set.
includesBootVolume_o True if the volume set includes the boot volume.
Notes:
There is currently only one volume set. In the future there could be others
(perhaps file servers; perhaps to support multiple local users).
}
FUNCTION FSVolumeSetGetInformation(volumeSet_t: FSVolumeSetObjID; VAR includesBootVolume_o: BOOLEAN; VAR object_o: FSObjectRef): OSStatus; C;
FUNCTION FSVolumeSetGetInformationAsync(volumeSet_t: FSVolumeSetObjID; {CONST}VAR completion_i: KernelNotification; VAR includesBootVolume_o: BOOLEAN; VAR object_o: FSObjectRef; VAR requestID_o: MessageID): OSStatus; C;
FUNCTION FSVolumeGetInformation(volume_t: FSVolumeObjID; VAR object_o: FSObjectRef): OSStatus; C;
FUNCTION FSVolumeGetInformationAsync(volume_t: FSVolumeObjID; {CONST}VAR completion_i: KernelNotification; VAR objectRef_o: FSObjectRef; VAR requestID_o: MessageID): OSStatus; C;
{ }
FUNCTION FSVolumeMount(device_t: ObjectID; requiredCapabilities_i: FSVolumeCapabilities; {CONST}VAR constraints_i: FSMountAccessConstraints; VAR volume_o: FSObjectRef): OSStatus; C;
FUNCTION FSVolumeMountAsync(device_t: ObjectID; requiredCapabilities_i: FSVolumeCapabilities; {CONST}VAR constraints_i: FSMountAccessConstraints; {CONST}VAR completion_i: KernelNotification; VAR volume_o: FSObjectRef; VAR requestID_o: MessageID): OSStatus; C;
{ }
FUNCTION FSVolumeUnmount(volume_t: FSObjectRef): OSStatus; C;
FUNCTION FSVolumeUnmountAsync(volume_t: FSObjectRef; {CONST}VAR completion_i: KernelNotification; VAR requestID_o: MessageID): OSStatus; C;
FUNCTION FSStreamAllocate(stream_t: FSStreamObjID; {CONST}VAR start_i: FSForkPositionDescriptor; length_i: FSSize; policy_i: FSForkAllocationPolicy; VAR actualAllocation_o: FSSize): OSStatus; C;
FUNCTION FSStreamAllocateAsync(stream_t: FSStreamObjID; {CONST}VAR start_i: FSForkPositionDescriptor; length_i: FSSize; policy_i: FSForkAllocationPolicy; {CONST}VAR completion_i: KernelNotification; VAR actualAllocation_o: FSSize; VAR requestID_o: MessageID): OSStatus; C;
{
Function: FSStreamClose
Purpose: Close a stream previously opened with FSStreamOpen or FSStreamOpenWithConstraints.
Inputs:
stream_t The stream to close.
Outputs:
Notes:
Any data written to the stream is flushed (written by the File Manager) before the
stream is closed. The FSStreamObjID, stream_t, may no longer be used. Any resources
allocated by the File Manager for use by this stream will be disposed.
}
FUNCTION FSStreamClose(stream_t: FSStreamObjID): OSStatus; C;
FUNCTION FSStreamCloseAsync(stream_t: FSStreamObjID; {CONST}VAR completion_i: KernelNotification; VAR requestID_o: MessageID): OSStatus; C;
{
Function: FSStreamFlush
Purpose: Any data written to the stream will be written by the File Manager.
Inputs:
stream_t The stream to flush.
Outputs:
Notes:
Stream data may still reside in the File Manager's caches, but any changes will have
been written out by the File Manager. Note that the underlying device's driver, or
the device itself, may cache some data, so the File Manager cannot guarantee that
all data has actually been written to the underlying media.
Other information about the object (such as its modification date) might not be flushed
by this call, though any volume-level data needed to access the stream will be.
}
FUNCTION FSStreamFlush(stream_t: FSStreamObjID): OSStatus; C;
FUNCTION FSStreamFlushAsync(stream_t: FSStreamObjID; {CONST}VAR completion_i: KernelNotification; VAR requestID_o: MessageID): OSStatus; C;
{ }
FUNCTION FSStreamGetEOF(stream_t: FSStreamObjID; VAR currentEOF_o: FSOffset): OSStatus; C;
FUNCTION FSStreamGetEOFAsync(stream_t: FSStreamObjID; {CONST}VAR completion_i: KernelNotification; VAR currentEOF_o: FSOffset; VAR requestID_o: MessageID): OSStatus; C;
{ }
FUNCTION FSStreamGetInformation(stream_t: FSStreamObjID; VAR object_o: FSObjectRef; VAR fork_o: FSProperty; VAR constraints_o: FSForkAccessConstraints): OSStatus; C;
FUNCTION FSStreamGetInformationAsync(stream_t: FSStreamObjID; {CONST}VAR completion_i: KernelNotification; VAR object_o: FSObjectRef; VAR fork_o: FSProperty; VAR constraints_o: FSForkAccessConstraints; VAR requestID_o: MessageID): OSStatus; C;
{
Function: FSStreamGetMark
Purpose: Returns the current mark (position offset) for a stream.
Inputs:
stream_t The stream.
Outputs:
currentMark_o Current offset in the stream, stream_t.
Notes:
This call returns the offset from the start of the file that would be
equivalent to using a FSForkPositionDescriptor whose positionOffset is
0, and whose positionMode is kFSFromMark. A stream's mark is set to
the byte following the last read or write, or via FSStreamSetMark.
}
FUNCTION FSStreamGetMark(stream_t: FSStreamObjID; VAR currentMark_o: FSOffset): OSStatus; C;
FUNCTION FSStreamGetMarkAsync(stream_t: FSStreamObjID; {CONST}VAR completion_i: KernelNotification; VAR currentMark_o: FSOffset; VAR requestID_o: MessageID): OSStatus; C;
{ }
FUNCTION FSStreamLockRange(stream_t: FSStreamObjID; {CONST}VAR position_i: FSForkPositionDescriptor; length_i: FSSize; options_i: FSRangeLockOptions; VAR rangeStart_o: FSOffset; VAR actualLength_o: FSSize): OSStatus; C;
FUNCTION FSStreamLockRangeAsync(stream_t: FSStreamObjID; {CONST}VAR position_i: FSForkPositionDescriptor; length_i: FSSize; options_i: FSRangeLockOptions; {CONST}VAR completion_i: KernelNotification; VAR rangeStart_o: FSOffset; VAR actualLength_o: FSSize; VAR requestID_o: MessageID): OSStatus; C;
{ }
FUNCTION FSStreamOpenWithConstraints(object_t: FSObjectRef; {CONST}VAR fork_i: FSProperty; {CONST}VAR constraints_i: FSForkAccessConstraints; VAR stream_o: FSStreamObjID): OSStatus; C;
FUNCTION FSStreamOpenWithConstraintsAsync(object_t: FSObjectRef; {CONST}VAR fork_i: FSProperty; {CONST}VAR constraints_i: FSForkAccessConstraints; {CONST}VAR completion_i: KernelNotification; VAR stream_o: FSStreamObjID; VAR requestID_o: MessageID): OSStatus; C;
{ }
FUNCTION FSStreamRead(stream_t: FSStreamObjID; {CONST}VAR position_i: FSForkPositionDescriptor; options_i: FSStreamIOOptions; VAR buffer_o: FSBufferDescriptor; VAR actualLength_o: ByteCount; VAR currentMark_o: FSOffset): OSStatus; C;
FUNCTION FSStreamReadAsync(stream_t: FSStreamObjID; {CONST}VAR position_i: FSForkPositionDescriptor; options_i: FSStreamIOOptions; {CONST}VAR completion_i: KernelNotification; VAR buffer_o: FSBufferDescriptor; VAR actualLength_o: ByteCount; VAR currentMark_o: FSOffset; VAR requestID_o: MessageID): OSStatus; C;
{ }
FUNCTION FSStreamReleaseAllocation(stream_t: FSStreamObjID; {CONST}VAR start_i: FSForkPositionDescriptor; length_i: FSSize; VAR actualLength_o: FSSize): OSStatus; C;
FUNCTION FSStreamReleaseAllocationAsync(stream_t: FSStreamObjID; {CONST}VAR start_i: FSForkPositionDescriptor; length_i: FSSize; {CONST}VAR completion_i: KernelNotification; VAR actualLength_o: FSSize; VAR requestID_o: MessageID): OSStatus; C;
{ }
FUNCTION FSStreamSetEOF(stream_t: FSStreamObjID; {CONST}VAR EOF_i: FSForkPositionDescriptor; policy_i: FSForkAllocationPolicy; VAR currentEOF_o: FSOffset): OSStatus; C;
FUNCTION FSStreamSetEOFAsync(stream_t: FSStreamObjID; {CONST}VAR EOF_i: FSForkPositionDescriptor; policy_i: FSForkAllocationPolicy; {CONST}VAR completion_i: KernelNotification; VAR currentEOF_o: FSOffset; VAR requestID_o: MessageID): OSStatus; C;
{
Function: FSStreamSetMark
Purpose: Sets the current mark (position offset) for a stream.
Inputs:
stream_t The stream.
newPosition_i The new position of the stream's mark.
options_i
Outputs:
originalMark_o The stream's mark, before being changed (relative
to the start of the stream).
currentMark_o The new mark, relative to the start of the stream.
Notes:
A stream's mark is usually used for sequential access to a stream,
or to position relative to the ending position of the last operation
on a stream. This call lets you explicitly set the mark for future
operations that will operate relative to the current mark.
If kFSMarkPinToEOF is set in options_i, and the new position specified
by newPosition_i would exceed the current end of the stream (also known
as End Of File or EOF), then the mark will be set to the EOF and E_NoError
is returned. Otherwise, an error will returned. The mark may never be
set past the end of the stream.
}
FUNCTION FSStreamSetMark(stream_t: FSStreamObjID; {CONST}VAR newPosition_i: FSForkPositionDescriptor; options_i: FSStreamSetMarkOptions; VAR originalMark_o: FSOffset; VAR currentMark_o: FSOffset): OSStatus; C;
FUNCTION FSStreamSetMarkAsync(stream_t: FSStreamObjID; {CONST}VAR newPosition_i: FSForkPositionDescriptor; options_i: FSStreamSetMarkOptions; {CONST}VAR completion_i: KernelNotification; VAR originalMark_o: FSOffset; VAR currentMark_o: FSOffset; VAR requestID_o: MessageID): OSStatus; C;
Purpose: Closes an access path to a file used for backing store.
Inputs:
backingStore_t The backing store object.
Outputs:
Notes:
Basically the same as FSStreamClose, but for a backing store.
All data written to this backing store (by writing to pages backed by
this store) will be flushed (written) by the File Manager.
}
FUNCTION FSMappedFileClose(backingStore_t: FSBackingStoreObjID): OSStatus; C;
FUNCTION FSMappedFileCloseAsync(backingStore_t: FSBackingStoreObjID; {CONST}VAR completion_i: KernelNotification; VAR requestID_o: MessageID): OSStatus; C;
{
Function: FSMappedFileGetEOF
Purpose: Return the EOF (length) of the fork being accessed by the given backing store.
Inputs:
backingStore_t The backing store used to access the fork.
Outputs:
currentEOF_o The size, in bytes, of the fork.
Notes:
Since access to a fork via a backing store (i.e. memory mapped file access) is
accomplished by directly accessing memory pages, the virtual memory system must
read and write entire pages. If the last page is modified, the entire page is
written, resulting in the fork size being rounded up to a multiple of a page size.
Similarly for access to pages beyond the fork's EOF.
This call returns the current EOF (length) of the underlying fork. This may be
set implicitly by writing to backed pages, or by using the FSBackingStoreSetEOF
call. It may also be changed by streams opened to the same fork.
}
FUNCTION FSMappedFileGetEOF(backingStore_t: FSBackingStoreObjID; VAR currentEOF_o: FSOffset): OSStatus; C;
FUNCTION FSMappedFileGetEOFAsync(backingStore_t: FSBackingStoreObjID; {CONST}VAR completion_i: KernelNotification; VAR currentEOF_o: FSOffset; VAR requestID_o: MessageID): OSStatus; C;
{ }
FUNCTION FSMappedFileGetInformation(backingStore_t: FSBackingStoreObjID; VAR object_o: FSObjectRef; VAR fork_o: FSProperty; VAR constraints_o: FSForkAccessConstraints): OSStatus; C;
FUNCTION FSMappedFileGetInformationAsync(backingStore_t: FSBackingStoreObjID; {CONST}VAR completion_i: KernelNotification; VAR object_o: FSObjectRef; VAR fork_o: FSProperty; VAR constraints_o: FSForkAccessConstraints; VAR requestID_o: MessageID): OSStatus; C;
{
Function: FSMappedFileSetEOF
Purpose: Sets the EOF (length) of the fork being accessed by the given backing store.
Inputs:
backingStore_t The backing store used to access the fork.
EOF_i The new length (EOF) of the fork.
policy_i Controls how space should be allocated (if the new EOF
is larger than the current EOF).
Outputs:
currentEOF_o The new size, in bytes, of the fork.
Notes:
Since access to a fork via a backing store (i.e. memory mapped file access) is
accomplished by directly accessing memory pages, the virtual memory system must
read and write entire pages. If the last page is modified, the entire page is
written, resulting in the fork size being rounded up to a multiple of a page size.
Similarly for access to pages beyond the fork's EOF.
This call allows the EOF to be explicitly set for a fork being accessed via a
backing store. Any data beyond the EOF will not actually be written to the fork.
The File Manager has no way to detect whether access to pages occurs beyond the
EOF; it is a programming error to access bytes beyond the EOF via a backing store.
This call would typically be used when a fork has been memory mapped to enable
convenient access to a file's data structures as if it were completely in memory.
You would make all changes to the data structures, then use this call to indicate
the number of bytes that are valid and should be written to the fork.
}
FUNCTION FSMappedFileSetEOF(backingStore_t: FSBackingStoreObjID; {CONST}VAR EOF_i: FSForkPositionDescriptor; policy_i: FSForkAllocationPolicy; VAR currentEOF_o: FSOffset): OSStatus; C;
FUNCTION FSMappedFileSetEOFAsync(backingStore_t: FSBackingStoreObjID; {CONST}VAR EOF_i: FSForkPositionDescriptor; policy_i: FSForkAllocationPolicy; {CONST}VAR completion_i: KernelNotification; VAR currentEOF_o: FSOffset; VAR requestID_o: MessageID): OSStatus; C;
{ }
FUNCTION FSMappedFileOpenWithConstraints(object_t: FSObjectRef; {CONST}VAR fork_i: FSProperty; {CONST}VAR constraints_i: FSForkAccessConstraints; VAR backingStore_o: FSBackingStoreObjID): OSStatus; C;
FUNCTION FSMappedFileOpenWithConstraintsAsync(object_t: FSObjectRef; {CONST}VAR fork_i: FSProperty; {CONST}VAR constraints_i: FSForkAccessConstraints; {CONST}VAR completion_i: KernelNotification; VAR backingStore_o: FSBackingStoreObjID; VAR requestID_o: MessageID): OSStatus; C;
FUNCTION FSObjectIterate(iterator_t: FSObjectIteratorObjID; objectCount_i: ItemCount; propertyCount_i: ItemCount; {CONST}VAR properties_i: FSPropertyDescriptor; VAR actualObjectCount_o: ItemCount; VAR propertiesBuffer_o: FSBufferDescriptor; VAR statusBuffer_o: FSBufferDescriptor): OSStatus; C;
FUNCTION FSObjectIterateAsync(iterator_t: FSObjectIteratorObjID; objectCount_i: ItemCount; propertyCount_i: ItemCount; {CONST}VAR properties_i: FSPropertyDescriptor; {CONST}VAR completion_i: KernelNotification; VAR actualObjectCount_o: ItemCount; VAR propertiesBuffer_o: FSBufferDescriptor; VAR statusBuffer_o: FSBufferDescriptor; VAR requestID_o: MessageID): OSStatus; C;
{
Function: FSObjectIteratorChangeCurrentScope
Purpose: Move an object iterator into or out of a container.
Inputs:
iterator_t The object iterator.
movement_i The direction to move: into or out of a container.
Outputs:
Notes:
If movement_i is kFSObjectEnter, then the iterator must be positioned on
an object that is capable of containing other objects; it does not need to
actually contain any objects at that time. That object will become the new
current scope of the iterator and it will be in Start Of Iteration state
(meaning that all objects in the current scope have yet to be returned).
The iterator will not be positioned on any object.
If movement_i is kFSObjectExit, then the current scope will become the object
that contains the current scope; the iterator's new position will be the object
that was the current scope. If the current scope and the outermost scope were
the same, then the outermost scope will also change to the new current scope and
E_ExitIteratorScope is returned (so that you realize you will be iterating outside
of the scope that you used to create the iterator; the iterator remains usable).
Object iterators keep track of all of the objects between the outermost scope and
the current scope (this is known as the "scope stack"). If any object in the scope
stack is moved, the iterator is invalidated and will return the error
E_IteratorScopeException until it has been explicitly fixed (by FSObjectIteratorRecreate)
or disposed. This call adds or removes objects from the scope stack.
}
FUNCTION FSObjectIteratorChangeCurrentScope(iterator_t: FSObjectIteratorObjID; movement_i: FSObjectIteratorMovement): OSStatus; C;
FUNCTION FSObjectIteratorChangeCurrentScopeAsync(iterator_t: FSObjectIteratorObjID; movement_i: FSObjectIteratorMovement; {CONST}VAR completion_i: KernelNotification; VAR requestID_o: MessageID): OSStatus; C;
{ }
FUNCTION FSObjectIteratorClone(iterator_t: FSObjectIteratorObjID; VAR clone_o: FSObjectIteratorObjID): OSStatus; C;
FUNCTION FSObjectIteratorCloneAsync(iterator_t: FSObjectIteratorObjID; {CONST}VAR completion_i: KernelNotification; VAR clone_o: FSObjectIteratorObjID; VAR requestID_o: MessageID): OSStatus; C;
{
Function: FSObjectIteratorCreate
Purpose: Create an iterator for iterating over objects.
Inputs:
outermostScope_t The initial outermost scope and current scope.
options_i Controls whether the iterator will traverse objects in
a single container or all embedded (nested) containers.
Also controls which kinds of objects will be returned.
Outputs:
iterator_o The object iterator.
Notes:
The outermost scope and current scope of the iterator are set to outermostScope_t.
The iterator is not positioned on any object, though it is inside outermostScope_t.
OutermostScope_t must be an object capable of containing other objects (such as the
Universe, a volume set, a volume, or a folder). The iterator is put into "Start Of
Iteration" state, meaning that all objects in the current scope have yet to be
returned.
The File Manager allocates resources and maintains state for every iterator. When
you have finished using an iterator, you should call FSObjectIteratorDispose to dispose
of it.
}
FUNCTION FSObjectIteratorCreate(outermostScope_t: FSObjectRef; options_i: FSObjectIteratorCreationOptions; VAR iterator_o: FSObjectIteratorObjID): OSStatus; C;
FUNCTION FSObjectIteratorCreateAsync(outermostScope_t: FSObjectRef; options_i: FSObjectIteratorCreationOptions; {CONST}VAR completion_i: KernelNotification; VAR iterator_o: FSObjectIteratorObjID; VAR requestID_o: MessageID): OSStatus; C;
{
Function: FSObjectIteratorDispose
Purpose: Dispose of an object iterator.
Inputs:
iterator_t The object iterator.
Outputs:
Notes:
The File Manager will dispose of the iterator and release any resources
allocated to the iterator. Further attempts to use the iterator will result
in an error.
}
FUNCTION FSObjectIteratorDispose(iterator_t: FSObjectIteratorObjID): OSStatus; C;
FUNCTION FSObjectIteratorDisposeAsync(iterator_t: FSObjectIteratorObjID; {CONST}VAR completion_i: KernelNotification; VAR requestID_o: MessageID): OSStatus; C;
{ }
FUNCTION FSObjectIteratorGetInformation(iterator_t: FSObjectIteratorObjID; VAR outermostScope_o: FSObjectRef; VAR currentScope_o: FSObjectRef; VAR options_o: FSObjectIteratorCreationOptions; VAR state_o: FSObjectIteratorState): OSStatus; C;
FUNCTION FSObjectIteratorGetInformationAsync(iterator_t: FSObjectIteratorObjID; {CONST}VAR completion_i: KernelNotification; VAR outermostScope_o: FSObjectRef; VAR currentScope_o: FSObjectRef; VAR options_o: FSObjectIteratorCreationOptions; VAR state_o: FSObjectIteratorState; VAR requestID_o: MessageID): OSStatus; C;
Purpose: Exchange the properties of two objects. Typically used for "safe
saving", while maintaining an object's persistent reference.
Inputs:
object1_i One object.
object2_i The object to exchange it with.
Outputs:
Notes:
This call is used to allow a "safe save" that preserves an object's
persistent reference. For example, you might want to save an updated
set of properties to an object so that any errors while saving result
in the object being unchanged; but, you also want the object's persistent
reference to remain unchanged (so that things like aliases still work).
What you would do is create a second object somewhere (in a temporary
folder, for example). Write out all of the properties, both unchanged
and changed, to the second object. When done saving, you would call
FSObjectExchange with both objects; the contents of the two objects get
swapped in such a way that the original object has the new properties,
but retains its old persistent reference.
}
FUNCTION FSObjectExchange(object1_i: FSObjectRef; object2_i: FSObjectRef): OSStatus; C;
FUNCTION FSObjectExchangeAsync(object1_i: FSObjectRef; object2_i: FSObjectRef; {CONST}VAR completion_i: KernelNotification; VAR requestID_o: MessageID): OSStatus; C;
{
Function: FSObjectRefGetFSSpec
Purpose: Return an FSSpec for an object (suitable for use with the Files API).
Inputs:
object_t The object.
Outputs:
fSSpec_o An FSSpec that specifies the same object as object_t,
suitable for use with the Files API.
Notes:
This call is intended to be used by code that is required to use both the
Files API and the FileManager API (or has clients that use both APIs).
For example, a piece of code may already exist with an API that uses FSSpecs,
but has been converted internally to use the FSObjectRefs; it would use this
call to produce an FSSpec as an output for the pre-existing API.
It would be best to provide an API that allows its clients to use FSObjectRefs.
}
FUNCTION FSObjectRefGetFSSpec(object_t: FSObjectRef; VAR fSSpec_o: FSSpec): OSStatus; C;
FUNCTION FSObjectRefGetFSSpecAsync(object_t: FSObjectRef; {CONST}VAR completion_i: KernelNotification; VAR fSSpec_o: FSSpec; VAR requestID_o: MessageID): OSStatus; C;
{ }
FUNCTION FSObjectLocate(container_t: FSObjectRef; elementCount_i: ItemCount; {CONST}VAR pathway_i: FSObjectPathwayElement; {CONST}VAR pathwayPropertiesBuffer_i: FSBufferDescriptor; VAR object_o: FSObjectRef): OSStatus; C;
FUNCTION FSObjectLocateAsync(container_t: FSObjectRef; elementCount_i: ItemCount; {CONST}VAR pathway_i: FSObjectPathwayElement; {CONST}VAR pathwayPropertiesBuffer_i: FSBufferDescriptor; {CONST}VAR completion_i: KernelNotification; VAR object_o: FSObjectRef; VAR requestID_o: MessageID): OSStatus; C;
{ }
FUNCTION FSObjectPersistentReferenceResolve(volume_t: FSVolumeObjID; {CONST}VAR persistentReference_i: FSObjectPersistentReference; VAR object_o: FSObjectRef): OSStatus; C;
FUNCTION FSObjectPersistentReferenceResolveAsync(volume_t: FSVolumeObjID; {CONST}VAR persistentReference_i: FSObjectPersistentReference; {CONST}VAR completion_i: KernelNotification; VAR object_o: FSObjectRef; VAR requestID_o: MessageID): OSStatus; C;
{ }
FUNCTION FSObjectRefResolve(object_t: FSObjectRef; VAR objectsVolume_o: FSVolumeObjID; VAR objectsVolumeSet_o: FSVolumeSetObjID): OSStatus; C;
FUNCTION FSObjectRefResolveAsync(object_t: FSObjectRef; {CONST}VAR completion_i: KernelNotification; VAR objectsVolume_o: FSVolumeObjID; VAR objectsVolumeSet_o: FSVolumeSetObjID; VAR requestID_o: MessageID): OSStatus; C;
{
Function: FSSpecGetFSObjectRef
Purpose: Return an FSObjectRef for an object specified via an FSSpec.
Inputs:
theFSSpec_t An FSSpec for the object.
Outputs:
theObject_o An FSObjectRef for the object.
Notes:
This call is intended to be used by code that is required to use both the
Files API and the FileManager API (or has clients that use both APIs).
For example, a piece of code may already exist with an API that uses FSSpecs,
but has been converted internally to use the FSObjectRefs; it would use this
call to take an input FSSpec and convert it to an FSObjectRef to use internally;
the FSObjectRef would then be disposed before completing the call.
It would be best to provide an API that allows its clients to use FSObjectRefs.
}
FUNCTION FSSpecGetFSObjectRef({CONST}VAR theFSSpec_t: FSSpec; VAR theObject_o: FSObjectRef): OSStatus; C;
{ }
FUNCTION FSUniverseResolve(VAR theUniverse_o: FSObjectRef): OSStatus; C;
FUNCTION FSUniverseResolveAsync(VAR theUniverse_o: FSObjectRef; {CONST}VAR theCompletion_i: KernelNotification; VAR theRequestID_o: MessageID): OSStatus; C;
{ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> F a c i l i t i e s <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< }
